{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e3ebd76a",
   "metadata": {},
   "source": [
    "# SimPy 仿真快速上手教程之我的赛博机场 🛫\n",
    "\n",
    "最近的课程大作业的选题可以是基于 SimPy 的仿真项目，所以我快速写个 SimPy 入门教程，方便大家上手。\n",
    "\n",
    "考虑到大家读写代码的实际能力和实际情况，这份教程我会做到 **尽可能事无巨细。** 📝\n",
    "\n",
    "我这里拿一个机场的例子给大家举例。毕竟谁没有梦想过，拥有一个自己的机场呢，对不对？既然我们没有办法拥有一个真正的机场，那么拥有一个在计算机里能够跑起来的仿真机场，或许可以给我们无法实现的童年梦想一个慰藉（bushi）"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b91e91c",
   "metadata": {},
   "source": [
    "## 导入所需要的库包 📦\n",
    "\n",
    "- `time`：用来处理时间 ⏰。内建工具包，无需 `pip` 安装。**在 SimPy 中，时间是直接用一个 float 类型的变量储存的。我们可以用 time 内建工具包转化为 h-m-s 的格式**。\n",
    "- `numpy`：**numpy 工具包在仿真中的实际作用主要是建立各种各样的概率分布**。比如在排队论当中，有大量的事件都是以概率的形式描述的，比如一组服务时间，就可能是一组正态分布，所以我们需要能拍工具包来帮我们计算正态分布。具体符合什么分布可以查论\n",
    "- `simpy` **离散事件仿真工具包**。可以用下面的命令安装 📥：\n",
    "\n",
    "```bash\n",
    "pip install simpy\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3fb25d86",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import simpy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f12529fc",
   "metadata": {},
   "source": [
    "## 手把手教你建一个属于自己的仿真机场"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66104ca5",
   "metadata": {},
   "source": [
    "### 揪心的玩笑和漫长的白日梦 🌝\n",
    "\n",
    "建立一个仿真机场的第一步就是做白日梦。\n",
    "\n",
    "首先先不要考虑仿真过程具体怎么实现，脑子里先描绘一副想象中的仿真的机场的样子。比如我想要一个很大的机场，这个机场要有两条跑道、八个登机口、三个地勤组；而且我的机场必须非常繁忙非常热闹，富得流油，每隔十分钟就会有一架航班抵达。而且我的地勤组很牛逼，半个小时就能整备好一架飞机。\n",
    "\n",
    "在这种情况下，我首先设置一组机场的参数。这组参数相当于机场的指标的描述性信息："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "069b45ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 跑道、登机口和地勤小组的数量\n",
    "RUNWAR_NUM = 2\n",
    "GATEWAY_NUM = 8 \n",
    "GROUND_SERVICE_GROUP_NUM = 3\n",
    "\n",
    "# 航班抵达的时间间隔、着陆和起飞花费的时间\n",
    "AIRWAY_TIME_GAP = 10 * 60\n",
    "AIRWAY_TIME_LANDING = 10 * 60\n",
    "AIRWAY_TIME_TAKEOFF = 5 * 60\n",
    "\n",
    "# 地勤组工作所需的时间\n",
    "GROUND_SERVICE_TIME = 30 * 60\n",
    "\n",
    "# 将会到达的飞机数量\n",
    "TOTAL_PLANE_NUM = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07b18505",
   "metadata": {},
   "source": [
    "不用担心漏掉什么参数——因为你发现之后随时可以上来补上。很方便的。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e86e096a",
   "metadata": {},
   "source": [
    "### 理清楚一个机场的逻辑\n",
    "\n",
    "搞仿真的第二个重要步骤就是你得弄清楚这个机场每天都在干什么。首先，我们来整理一下我们想象中的这个机场每天会发生的事情。\n",
    "\n",
    "**简单的来讲，机场每天会发生下面的几件事情：**\n",
    "\n",
    "1. 每天都会有飞机抵达机场。飞机抵达机场之后，首先会申请占用跑道。\n",
    "\n",
    "2. 获得占用跑道的申请之后，就会着陆，占用跑道一段时间；\n",
    "\n",
    "3. 等到飞机降落之后就会离开跑道，来到停机坪，也就是登机口的位置。\n",
    "\n",
    "4. 然后经过地勤30分钟的打理之后，离开登机口，再次申请跑道起飞，然后继续占用跑道一段时间。\n",
    "\n",
    "虽然排队论我没有学明白，但是如果我没搞错的话，在排队论当中应该是有服务台和仓库的概念的。我们这里也可以把跑道和地勤组考虑为服务台，把登机口考虑为仓库。\n",
    "\n",
    "为什么要这样考虑呢？我也不知道为什么要这样考虑，只是觉得这样行得通，所以就这样考虑了，但是我排队论学得很烂，所以我说不准。问题就在于，比如这个跑道跑道能不能考虑为一个仓库呢？反正两根跑道对吧，容量是有限的。然后把飞机考虑为货。还是应该把登机口考虑为服务台呢？到底哪一种方案更好，我也说不准。反正我这里就先按照自己的感觉这样设计了。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34401c11",
   "metadata": {},
   "source": [
    "**下面这张图直观地展示了我们现在的思路。**\n",
    "\n",
    "其中，方块表示服务台，圆柱形表示仓库对象。每一家进入机场的航班，就在下图中的箭线表示的路径上排队。\n",
    "\n",
    "![极简机场仿真](./image/simAirport.drawio.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f1f0459",
   "metadata": {},
   "source": [
    "### SimPy 如何实现这种逻辑\n",
    "\n",
    "可以参考知乎文章 [Python SimPy 仿真系列 (1)](https://zhuanlan.zhihu.com/p/31526894)，里面说的详细。我这边就举几个简单的。\n",
    "\n",
    "#### 虚拟环境\n",
    "\n",
    "- `env.Environment()` SimPy 的虚拟环境\n",
    "\n",
    "在虚拟环境下逻辑地实现的基本工具主要是这几个：\n",
    "\n",
    "#### Store - 抽象队列 📦\n",
    "\n",
    "- `simpy.Store` - 存取 item 遵循仿真时间上的先到后到\n",
    "- `simpy.Container` - 表达连续/不可分的物质, 包括液体/气体的存放, 存取的是一个 float 数值\n",
    "\n",
    "#### Resource - 抽象资源 💁\n",
    "\n",
    "- `simpy.Resource` - 表达人力资源或某种限制条件, 例如某个工序可调用的工人数, 可以调用的机器数"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3aefdd98",
   "metadata": {},
   "source": [
    "### 定义机场类\n",
    "\n",
    "我们现在需要定义一个新的类，叫做机场。\n",
    "\n",
    "**你会看见我下面的代码里面定义停机坪 / 登机口用的是 `simpy.Container` 而不是 `simpy.Store`，这是因为我研究 `simpy.Store` 一直报错而中文互联网上资料又特别少，为了赶着出这份教程，直接用了 `simpy.Container` 临时代替。这个做法是不对的，毕竟飞机不是什么能够装在杯子里流来流去的东西。但是我这边 `simpy.Store` 一直出问题。**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c667a96f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class AirPort():\n",
    "    def __init__(\n",
    "        self, env, \n",
    "        num_runway, # 机场的跑道数量\n",
    "        num_gateway, # 机场的登机口数量\n",
    "        num_gs_group, # 机场的地勤组数量\n",
    "        ):\n",
    "        \n",
    "        self.env = env # 仿真环境对象\n",
    "        # 两个服务台对象\n",
    "        self.runway = simpy.Resource(\n",
    "            env, capacity=num_runway)\n",
    "        self.gs_group = simpy.Resource(\n",
    "            env, capacity=num_gs_group)\n",
    "        # 一个仓库对象\n",
    "        self.gateway = simpy.Container(\n",
    "            env, capacity=num_gateway, \n",
    "            init=0) # 初始状态下这里会有 0 架飞机\n",
    "        self.airplane_record_dict = {\n",
    "            'id' : [],\n",
    "            'arrival_time' : [],\n",
    "            'takeoff_time' : []\n",
    "        }\n",
    "        # 准备一个字典，记录每架飞机的信息\n",
    "\n",
    "        # 使用字典的方式保存每一架飞机的信息。\n",
    "        # 这些信息将会被用于统计排队参数、数据可视化等。\n",
    "        \n",
    "    def record_plane_info(\n",
    "            self, plane_id, arrival_time, takeoff_time\n",
    "        ):\n",
    "        \"\"\" 记录飞机到达的时间、起飞的时间，追加到字典\n",
    "        \"\"\"\n",
    "        self.airplane_record_dict['id'].append(plane_id)\n",
    "        self.airplane_record_dict['arrival_time'].append(arrival_time)\n",
    "        self.airplane_record_dict['takeoff_time'].append(takeoff_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05d56d04",
   "metadata": {},
   "source": [
    "### 飞机的抵达和进场 🛬💺\n",
    "\n",
    "可以被理解为这个仿真的主事件循环。\n",
    "\n",
    "`yield` 关键字和 Python 中一种特殊的对象类型——迭代器，有关。可以不用理解 `yield` 关键字是干什么用的（不难理解，但是我觉得在这里不需要花心思去解释）。只要记住这个地方要用 `yield` 来声明就好了。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f5adb08a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def airline_arrivial(\n",
    "    env, airport, # 函数要传入机场和虚拟环境\n",
    "    total_plane,  # 飞机总数\n",
    "    time_gap,     # 来飞机的时间间隔\n",
    "    time_landing  # 飞机着陆所需的时间\n",
    "    ): \n",
    "    for plane_id in range(total_plane): \n",
    "        yield env.timeout( # 延迟一段时间\n",
    "            max(\n",
    "                1, # 考虑为泊松分布。（下面详解这段代码）\n",
    "                np.random.poisson(time_gap)\n",
    "            ) )\n",
    "        print( # 每当出现一架新的航班在排队准备降落\n",
    "            \"plane No.\", plane_id, \n",
    "            \"is waiting to land\",\n",
    "            \"at time\", # 打印一下这是第几架航班\n",
    "            time.strftime(\n",
    "                \"%H:%M:%S\", \n",
    "                time.gmtime(env.now)))\n",
    "        arrival_time = env.now # 飞机的到达时间就是仿真系统现在的时间\n",
    "        with airport.runway.request() as request:\n",
    "            yield request\n",
    "            yield env.timeout(\n",
    "                max(\n",
    "                    1, \n",
    "                    np.random.poisson(time_landing)\n",
    "                ) )\n",
    "        airport.gateway.put(1)\n",
    "        env.process(ground_service(\n",
    "            env, airport, plane_id, \n",
    "            GROUND_SERVICE_TIME, \n",
    "            AIRWAY_TIME_TAKEOFF,\n",
    "            arrival_time\n",
    "        ))\n",
    "        print(\"plane No.\", plane_id, \n",
    "              \"landed at time\", \n",
    "              time.strftime(\n",
    "                  \"%H:%M:%S\", \n",
    "                  time.gmtime(env.now)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0890eed2",
   "metadata": {},
   "source": [
    "在上面的这段代码中，这段内容可能不好理解：\n",
    "\n",
    "```python\n",
    "yield env.timeout( # 延迟一段时间\n",
    "            max(\n",
    "                1, # 考虑为泊松分布。（下面详解这段代码）\n",
    "                np.random.poisson(time_gap)\n",
    "            ) )\n",
    "```\n",
    "\n",
    "这段内容的意思是说，首先利用 `yield` 这个关键字，让 SimPy 仿真环境中的当前进程延迟一段时间。而延迟时间的长度，是一个 `max()` 函数的返回值。\n",
    "\n",
    "我们知道，在 Python 编程语言中，`max()` 这个内建函数的作用，可以对多个数字取最大。也就是说，在这里，`yield` 关键字是在 `1` 和 `np.random.poisson(time_gap)` 之间取最大。\n",
    "\n",
    "`np.random.poisson()`，是 numpy 工具包提供的泊松分布函数。这个函数在这里的功能，是允许你传入一个 $\\lambda$ 的值，然后返回随机数，返回的随机数符合一个泊松分布。\n",
    "\n",
    "也许你想问：**为什么要把 1 和泊松分布 $P(\\lambda)$ 放在一起比大小，而不是直接拿泊松分布来生成时间呢？** 原因很简单：因为 `np.random.poisson()` 是会生成负数的，但是延迟时间不可能是负数。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8683d1fc",
   "metadata": {},
   "source": [
    "### 地勤服务的流程"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0da1c357",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ground_service(\n",
    "    env, airport, plane_id, \n",
    "    operation_time, takeoff_time,\n",
    "    arrival_time):\n",
    "    with airport.gs_group.request() as request:\n",
    "        yield request\n",
    "        yield env.timeout(\n",
    "            max(\n",
    "            1, \n",
    "            np.random.poisson(operation_time)\n",
    "            # 这里是服务时间\n",
    "            # 应该为负指数分布\n",
    "        ) )\n",
    "    print(\n",
    "        \"plane No.\", plane_id, \n",
    "        \"is ready to leave at\", \n",
    "        time.strftime(\n",
    "            \"%H:%M:%S\", \n",
    "            time.gmtime(env.now)))\n",
    "    env.process(airplane_takeoff(\n",
    "        env, airport, \n",
    "        plane_id, takeoff_time,\n",
    "        arrival_time))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35cbb48f",
   "metadata": {},
   "source": [
    "### 飞机的起飞和离开"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ec6a26d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def airplane_takeoff(\n",
    "    env, airport, \n",
    "    plane_id, takeoff_time,\n",
    "    arrival_time):\n",
    "    with airport.runway.request() as request:\n",
    "        yield request\n",
    "        yield env.timeout(\n",
    "            max(\n",
    "            1, \n",
    "            np.random.poisson(takeoff_time)\n",
    "        ) )\n",
    "        print(\"plane No.\", plane_id, \n",
    "              \"take off at\", \n",
    "              time.strftime(\n",
    "                  \"%H:%M:%S\", \n",
    "                  time.gmtime(env.now)))\n",
    "        airport.gateway.get(1)\n",
    "        takeoff_time = env.now\n",
    "        airport.record_plane_info(\n",
    "            plane_id, arrival_time, takeoff_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3ac143e",
   "metadata": {},
   "source": [
    "### 整合环境并进入进程"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "663b49e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "env = simpy.Environment()\n",
    "airport = AirPort(\n",
    "    env, \n",
    "    RUNWAR_NUM, \n",
    "    GATEWAY_NUM,\n",
    "    GROUND_SERVICE_GROUP_NUM)\n",
    "airline_arrivial_process = env.process(\n",
    "    airline_arrivial(\n",
    "        env, airport,\n",
    "        TOTAL_PLANE_NUM,\n",
    "        AIRWAY_TIME_GAP,\n",
    "        AIRWAY_TIME_LANDING))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "802c093e",
   "metadata": {},
   "source": [
    "## 运行机场仿真\n",
    "\n",
    "这里给到我们的仿真机场 10000 秒的时间。给大家看看效果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e2a40288",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "plane No. 0 is waiting to land at time 00:09:13\n",
      "plane No. 0 landed at time 00:20:02\n",
      "plane No. 1 is waiting to land at time 00:29:46\n",
      "plane No. 1 landed at time 00:39:13\n",
      "plane No. 2 is waiting to land at time 00:49:15\n",
      "plane No. 0 is ready to leave at 00:50:19\n",
      "plane No. 0 take off at 00:55:23\n",
      "plane No. 2 landed at time 00:59:43\n",
      "plane No. 1 is ready to leave at 01:08:53\n",
      "plane No. 3 is waiting to land at time 01:09:52\n",
      "plane No. 1 take off at 01:13:50\n",
      "plane No. 3 landed at time 01:19:50\n",
      "plane No. 4 is waiting to land at time 01:30:22\n",
      "plane No. 2 is ready to leave at 01:30:40\n",
      "plane No. 2 take off at 01:35:36\n",
      "plane No. 4 landed at time 01:40:34\n",
      "plane No. 3 is ready to leave at 01:49:43\n",
      "plane No. 5 is waiting to land at time 01:51:01\n",
      "plane No. 3 take off at 01:54:59\n",
      "plane No. 5 landed at time 02:01:59\n",
      "plane No. 4 is ready to leave at 02:11:57\n",
      "plane No. 6 is waiting to land at time 02:12:05\n",
      "plane No. 4 take off at 02:17:19\n",
      "plane No. 6 landed at time 02:22:00\n",
      "plane No. 7 is waiting to land at time 02:31:57\n",
      "plane No. 5 is ready to leave at 02:32:12\n",
      "plane No. 5 take off at 02:37:22\n",
      "plane No. 7 landed at time 02:42:18\n",
      "plane No. 6 is ready to leave at 02:51:46\n",
      "plane No. 8 is waiting to land at time 02:52:19\n",
      "plane No. 6 take off at 02:56:58\n",
      "plane No. 8 landed at time 03:02:23\n",
      "plane No. 7 is ready to leave at 03:12:33\n",
      "plane No. 9 is waiting to land at time 03:12:35\n",
      "plane No. 7 take off at 03:17:22\n",
      "plane No. 9 landed at time 03:23:07\n",
      "plane No. 8 is ready to leave at 03:32:15\n",
      "plane No. 8 take off at 03:37:20\n",
      "plane No. 9 is ready to leave at 03:52:34\n",
      "plane No. 9 take off at 03:57:09\n"
     ]
    }
   ],
   "source": [
    "env.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d279fef3",
   "metadata": {},
   "source": [
    "## 查看和分析仿真结果 📊📉📈"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd63bed1",
   "metadata": {},
   "source": [
    "### 计算平均滞留时间"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c768801d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>arrival_time</th>\n",
       "      <th>takeoff_time</th>\n",
       "      <th>stay_time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>553</td>\n",
       "      <td>3323</td>\n",
       "      <td>2770</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>1786</td>\n",
       "      <td>4430</td>\n",
       "      <td>2644</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>2955</td>\n",
       "      <td>5736</td>\n",
       "      <td>2781</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>4192</td>\n",
       "      <td>6899</td>\n",
       "      <td>2707</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>5422</td>\n",
       "      <td>8239</td>\n",
       "      <td>2817</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>5</td>\n",
       "      <td>6661</td>\n",
       "      <td>9442</td>\n",
       "      <td>2781</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>6</td>\n",
       "      <td>7925</td>\n",
       "      <td>10618</td>\n",
       "      <td>2693</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>7</td>\n",
       "      <td>9117</td>\n",
       "      <td>11842</td>\n",
       "      <td>2725</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>8</td>\n",
       "      <td>10339</td>\n",
       "      <td>13040</td>\n",
       "      <td>2701</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>9</td>\n",
       "      <td>11555</td>\n",
       "      <td>14229</td>\n",
       "      <td>2674</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   id  arrival_time  takeoff_time  stay_time\n",
       "0   0           553          3323       2770\n",
       "1   1          1786          4430       2644\n",
       "2   2          2955          5736       2781\n",
       "3   3          4192          6899       2707\n",
       "4   4          5422          8239       2817\n",
       "5   5          6661          9442       2781\n",
       "6   6          7925         10618       2693\n",
       "7   7          9117         11842       2725\n",
       "8   8         10339         13040       2701\n",
       "9   9         11555         14229       2674"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sim_res = pd.DataFrame(airport.airplane_record_dict)\n",
    "sim_res['stay_time'] = sim_res['takeoff_time'] - sim_res['arrival_time']\n",
    "sim_res"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50d16102",
   "metadata": {},
   "source": [
    "### 数据可视化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "30d800d2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: >"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "sim_res[['stay_time']].plot.line()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b7f42b6",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
